const app = getApp()
const api = require('../../utils/request')

Page({
  /**
   * 页面的初始数据
   * userInfo: 用户基本信息对象
   * healthInfo: 用户健康信息对象
   * medicalHistory: 用户病史信息对象
   * riskLevels: 风险等级选项数组
   * diabetesTypes: 糖尿病类型选项数组
   */
  data: {
    userInfo: {},
    healthInfo: {
      height: '',      // 身高(cm)
      weight: '',      // 体重(kg)
      bmi: '',         // BMI值
      waistline: '',   // 腰围(cm)
      bloodType: '',   // 血型
      diabetesType: 0, // 糖尿病类型: 0-无, 1-1型, 2-2型, 3-妊娠, 4-其他
      diagnosisYear: '', // 确诊年份
      riskLevel: 0     // 风险等级: 0-低风险, 1-中风险, 2-高风险
    },
    medicalHistory: {
      hasDiabetes: false,       // 是否患有糖尿病
      hasHypertension: false,   // 是否患有高血压
      hasHeartDisease: false,   // 是否患有心脏病
      hasKidneyDisease: false,  // 是否患有肾病
      familyDiabetes: false,    // 家族是否有糖尿病史
      medications: []           // 当前服用的药物列表
    },
    bloodTypes: ['A型', 'B型', 'AB型', 'O型'],
    diabetesTypes: ['无', '1型糖尿病', '2型糖尿病', '妊娠糖尿病', '其他类型'],
    riskLevels: ['低风险', '中风险', '高风险'],
    // 体力活动水平选项
    activityLevels: ['轻度(Ⅰ)', '中度(Ⅱ)', '重度(Ⅲ)'],
    // 生理状况选项
    physiologicalStatuses: ['普通', '孕早期(1-12周)', '孕中期(13-27周)', '孕晚期(28周以上)', '哺乳期'],
    years: [],  // 年份选择器数据
    isNewUser: false, // 是否为新用户
    needSaveReminder: false, // 是否需要提醒保存
    isEditing: false, // 是否处于编辑模式
    originalData: {}, // 保存原始数据，用于取消时恢复
    loading: true
  },

  /**
   * 生命周期函数--监听页面加载
   * 初始化用户信息和生成年份选项
   */
  onLoad(options) {
    this.initYears()
    this.fetchUserData()
  },

  /**
   * 生命周期函数--监听页面显示
   * 检查是否需要刷新数据
   */
  onShow() {
    console.log("userDetail页面显示，重新获取最新数据");
    // 每次显示页面时都刷新数据，确保显示最新内容
    this.fetchUserData();
  },

  /**
   * 刷新用户信息的统一入口
   * 可由其他页面直接调用
   */
  loadUserInfo() {
    this.fetchUserData()
  },

  /**
   * 初始化年份选择器数据
   */
  initYears() {
    // 生成年份选择器数据，从1950年到当前年份
    const currentYear = new Date().getFullYear()
    const years = []
    for (let i = currentYear; i >= 1950; i--) {
      years.push(i.toString())
    }
    this.setData({ years })
  },

  /**
   * 获取用户数据
   */
  async fetchUserData() {
    wx.showLoading({
      title: '获取最新数据...',
      mask: true
    });
    
    try {
      this.setData({ loading: true });
      
      console.log("开始获取用户资料数据");
      
      // 获取用户基本信息
      const userInfoRes = await api.getUserProfile();
      console.log("API返回结果:", userInfoRes);
      
      if (userInfoRes && userInfoRes.success) {
        // 确保年龄正确显示
        const userData = userInfoRes.data;
        
        // 调试日志：输出原始用户数据
        console.log('==================== 详细调试信息 ====================');
        console.log('API返回的原始用户数据:', userData);
        console.log('用户血型:', userData.bloodType);
        console.log('用户身高:', userData.height);
        console.log('用户体重:', userData.weight);
        console.log('用户BMI:', userData.bmi);
        
        // 如果后端返回了年龄，直接使用
        // 如果没有返回年龄但有出生日期，根据出生日期计算年龄
        if (!userData.age && userData.birthDate) {
          userData.age = this.calculateAge(userData.birthDate);
        }
        
        // 格式化出生日期
        if (userData.birthDate) {
          userData.birthDate = userData.birthDate.substring(0, 10); // 只取YYYY-MM-DD部分
        }
        
        this.setData({ userInfo: userData });
        
        // 处理健康信息
        const healthInfo = {
          height: userData.height || '',
          weight: userData.weight || '', // 直接从用户资料获取体重
          bmi: userData.bmi || '',       // 直接从用户资料获取BMI
          waistline: userData.waistline || '', // 从用户资料获取腰围
          bloodType: userData.bloodType || '', // 从用户资料获取血型
          diabetesType: userData.diabetesType ? this.getDiabetesTypeValue(userData.diabetesType) : 0,
          diagnosisYear: userData.diagnosisDate ? new Date(userData.diagnosisDate).getFullYear().toString() : '',
          riskLevel: 0
        };
        
        // 调试日志：输出处理后的健康信息
        console.log('处理后的健康信息:', healthInfo);
        console.log('处理后的血型:', healthInfo.bloodType);
        console.log('原始用户数据中的生理状况:', userData.physiologicalStatus);
        console.log('原始用户数据中的体力活动水平:', userData.activityLevel);
        console.log('==================== 调试信息结束 ====================');
        
        // 如果存在身高和体重，计算BMI（如果未从服务器获取）
        if (healthInfo.height && healthInfo.weight && !healthInfo.bmi) {
          const heightInMeters = healthInfo.height / 100;
          healthInfo.bmi = (healthInfo.weight / (heightInMeters * heightInMeters)).toFixed(1);
        }
        
        this.setData({ healthInfo });
        
        // 处理病史信息
        const medicalHistory = {
          hasDiabetes: userData.diabetesType && userData.diabetesType !== '无',
          hasHypertension: userData.hasHypertension || false,
          hasHeartDisease: userData.hasHeartDisease || false,
          hasKidneyDisease: userData.hasKidneyDisease || false,
          familyDiabetes: userData.familyDiabetes || false,
          medications: userData.medications || []
        };
        
        this.setData({ medicalHistory });

        // 确保生理状况和体力活动水平被正确设置到 userInfo 中
        const updatedUserInfo = {
          ...userData,
          physiologicalStatus: userData.physiologicalStatus || 'normal',
          activityLevel: userData.activityLevel || 'light'
        };
        this.setData({ userInfo: updatedUserInfo });
        
        console.log("用户数据获取和处理完成");
      } else {
        console.error('获取用户数据失败:', userInfoRes);
        wx.showToast({
          title: '获取数据失败',
          icon: 'none'
        });
      }
    } catch (err) {
      console.error('获取用户数据异常:', err);
      wx.showToast({
        title: '获取数据失败: ' + (err.message || '未知错误'),
        icon: 'none'
      });
    } finally {
      this.setData({ loading: false });
      wx.hideLoading();
    }
  },

  /**
   * 将糖尿病类型字符串转换为数值
   */
  getDiabetesTypeValue(typeString) {
    switch (typeString) {
      case '1型': return 1
      case '2型': return 2
      case '妊娠期': return 3
      case '其他': return 4
      default: return 0
    }
  },

  /**
   * 跳转到编辑页面
   */
  goToEdit() {
    wx.navigateTo({
      url: '/pages/userDetailEdit/userDetailEdit?edit=true'
    })
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    return {
      title: '糖尿病健康管理',
      path: '/pages/health/health'
    }
  },

  /**
   * 监听所有表单变化，如有修改则提示用户保存
   */
  watchFormChanges() {
    // 使用setData的回调监视数据变化
    const originalSetData = this.setData
    this.setData = (obj, callback) => {
      // 调用原始setData
      originalSetData.call(this, obj, () => {
        // 如果修改了关键数据且不是初始加载，则标记需要保存
        if (obj.userInfo || obj.healthInfo || obj.medicalHistory) {
          if (!this.data.isInitialLoad) {
            this.setData({
              needSaveReminder: true
            }, () => {})
          }
        }
        // 执行原始回调
        callback && callback()
      })
    }
    
    // 初始加载完成后设置标记
    setTimeout(() => {
      this.data.isInitialLoad = false
    }, 1000)
  },
  
  /**
   * 更换头像
   * 调用系统相册或相机API选择新头像
   */
  changeAvatar() {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'], // 压缩图片以节省空间
      sourceType: ['album', 'camera'], // 允许从相册或相机选择
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0]
        this.setData({
          'userInfo.avatarUrl': tempFilePath
        })
      }
    })
  },

  /**
   * 昵称变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onNicknameChange(e) {
    this.setData({
      'userInfo.nickName': e.detail.value
    })
  },

  /**
   * 性别变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onGenderChange(e) {
    this.setData({
      'userInfo.gender': parseInt(e.detail.value)
    })
  },

  /**
   * 年龄变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onAgeChange(e) {
    this.setData({
      'userInfo.age': e.detail.value
    })
  },

  /**
   * 身高变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onHeightChange(e) {
    const height = e.detail.value
    let bmi = ''
    
    // 如果身高和体重都存在，计算BMI
    if (height && this.data.healthInfo.weight) {
      const heightM = height / 100
      bmi = (this.data.healthInfo.weight / (heightM * heightM)).toFixed(1)
    }
    
    this.setData({
      'healthInfo.height': height,
      'healthInfo.bmi': bmi
    })
  },
  
  /**
   * 体重变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onWeightChange(e) {
    const weight = e.detail.value
    let bmi = ''
    
    // 如果身高和体重都存在，计算BMI
    if (this.data.healthInfo.height && weight) {
      const heightM = this.data.healthInfo.height / 100
      bmi = (weight / (heightM * heightM)).toFixed(1)
    }
    
    this.setData({
      'healthInfo.weight': weight,
      'healthInfo.bmi': bmi
    })
  },
  
  /**
   * 腰围变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onWaistlineChange(e) {
    this.setData({
      'healthInfo.waistline': e.detail.value
    })
  },
  
  /**
   * 血型变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onBloodTypeChange(e) {
    this.setData({
      'healthInfo.bloodType': e.detail.value
    })
  },
  
  /**
   * 糖尿病类型变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onDiabetesTypeChange(e) {
    const diabetesType = parseInt(e.detail.value)
    
    // 更新糖尿病类型
    this.setData({
      'healthInfo.diabetesType': diabetesType,
      'medicalHistory.hasDiabetes': diabetesType > 0 // 如果选择了类型，则标记为有糖尿病
    })
  },
  
  /**
   * 确诊年份变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onDiagnosisYearChange(e) {
    this.setData({
      'healthInfo.diagnosisYear': this.data.years[e.detail.value]
    })
  },
  
  /**
   * 风险等级变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onRiskLevelChange(e) {
    this.setData({
      'healthInfo.riskLevel': parseInt(e.detail.value)
    })
  },
  
  /**
   * 病史状态变化处理函数
   * @param {Object} e - 开关事件对象
   */
  onMedicalHistoryChange(e) {
    const field = e.currentTarget.dataset.field
    const value = e.detail.value
    
    // 构建要更新的数据对象
    const updateData = {}
    updateData[`medicalHistory.${field}`] = value
    
    // 如果是切换糖尿病状态，同步更新糖尿病类型
    if (field === 'hasDiabetes') {
      updateData['healthInfo.diabetesType'] = value ? (this.data.healthInfo.diabetesType || 2) : 0
    }
    
    this.setData(updateData)
  },
  
  /**
   * 自动评估风险等级
   * 基于用户的健康和病史信息计算风险等级
   */
  autoAssessRisk() {
    const { healthInfo, medicalHistory } = this.data
    let riskScore = 0
    
    // 计算风险分数
    // 1. BMI超标
    if (healthInfo.bmi > 28) {
      riskScore += 2
    } else if (healthInfo.bmi > 24) {
      riskScore += 1
    }
    
    // 2. 腰围风险（男性>90cm，女性>85cm为风险）
    const isMale = this.data.userInfo.gender === 1
    if ((isMale && healthInfo.waistline > 90) || (!isMale && healthInfo.waistline > 85)) {
      riskScore += 1
    }
    
    // 3. 已有疾病
    if (medicalHistory.hasDiabetes) riskScore += 3
    if (medicalHistory.hasHypertension) riskScore += 2
    if (medicalHistory.hasHeartDisease) riskScore += 2
    if (medicalHistory.hasKidneyDisease) riskScore += 2
    
    // 4. 家族史
    if (medicalHistory.familyDiabetes) riskScore += 1
    
    // 5. 年龄因素（45岁以上风险增加）
    if (this.data.userInfo.age > 60) {
      riskScore += 2
    } else if (this.data.userInfo.age > 45) {
      riskScore += 1
    }
    
    // 确定风险等级
    let riskLevel = 0
    if (riskScore >= 5) {
      riskLevel = 2 // 高风险
    } else if (riskScore >= 3) {
      riskLevel = 1 // 中风险
    }
    
    // 更新风险等级
    this.setData({
      'healthInfo.riskLevel': riskLevel
    })
    
    // 显示评估结果
    wx.showToast({
      title: `评估完成: ${this.data.riskLevels[riskLevel]}`,
      icon: 'success'
    })
  },

  /**
   * 开始编辑模式
   */
  startEditing() {
    // 保存原始数据，以便取消时恢复
    this.setData({
      originalData: {
        userInfo: JSON.parse(JSON.stringify(this.data.userInfo)),
        healthInfo: JSON.parse(JSON.stringify(this.data.healthInfo)),
        medicalHistory: JSON.parse(JSON.stringify(this.data.medicalHistory))
      },
      isEditing: true
    })
  },
  
  /**
   * 取消修改
   * 如果数据已修改，显示确认提示；否则直接返回编辑模式
   */
  cancelEdit() {
    if (this.data.needSaveReminder) {
      wx.showModal({
        title: '提示',
        content: '您的修改尚未保存，确定要取消吗？',
        success: (res) => {
          if (res.confirm) {
            this.restoreOriginalData()
          }
        }
      })
    } else {
      this.restoreOriginalData()
    }
  },
  
  /**
   * 恢复原始数据
   */
  restoreOriginalData() {
    // 如果是新用户，返回上一页
    if (this.data.isNewUser) {
      wx.navigateBack()
      return
    }
    
    // 恢复数据并退出编辑模式
    if (this.data.originalData.userInfo) {
      this.setData({
        userInfo: this.data.originalData.userInfo,
        healthInfo: this.data.originalData.healthInfo,
        medicalHistory: this.data.originalData.medicalHistory,
        isEditing: false,
        needSaveReminder: false
      })
    } else {
      this.setData({
        isEditing: false,
        needSaveReminder: false
      })
    }
  },

  /**
   * 保存用户信息
   * 验证数据并提交到服务器
   */
  async saveUserInfo() {
    const { userInfo, healthInfo, medicalHistory } = this.data
    
    // 基本验证
    if (!userInfo.nickName) {
      wx.showToast({
        title: '请输入昵称',
        icon: 'none'
      })
      return
    }
    
    // 显示保存中提示
    wx.showLoading({
      title: '保存中...',
      mask: true
    })
    
    try {
      // 保存用户基本信息
      await api.getUserProfile(userInfo)
      
      // 保存健康信息
      await api.healthTarget.updateHealthInfo(healthInfo)
      
      // 保存病史信息
      await api.medicalHistory.updateMedicalHistory(medicalHistory)

    // 更新全局数据
    app.globalData.userInfo = userInfo
      
    // 更新本地存储
    wx.setStorageSync('userInfo', userInfo)

      // 隐藏加载提示
      wx.hideLoading()
      
      // 重置保存提醒标志
      this.setData({
        needSaveReminder: false,
        isEditing: false // 退出编辑模式
      })
      
      // 显示成功提示
    wx.showToast({
      title: '保存成功',
        icon: 'success'
      })
      
      // 如果是新用户，保存后跳转到主页
      if (this.data.isNewUser) {
        setTimeout(() => {
          wx.switchTab({
            url: '/pages/health/health'
          })
        }, 1500)
      }
    } catch (err) {
      // 隐藏加载提示
      wx.hideLoading()
      
      console.error('保存用户信息失败:', err)
      wx.showToast({
        title: '保存失败，请重试',
        icon: 'none'
      })
    }
  },
  
  /**
   * 生命周期函数--监听页面离开
   * 如有未保存变更，提示用户
   */
  onUnload() {
    if (this.data.needSaveReminder && this.data.isEditing) {
      // 提醒用户数据未保存的信息已经通过beforeunload事件处理
      console.log('页面关闭，存在未保存的修改')
    }
  },
  
  /**
   * 监听页面返回事件
   * 如有未保存的修改，询问用户是否确认离开
   */
  onBeforeBack() {
    // 如果有未保存的修改且处于编辑模式，拦截返回事件
    if (this.data.needSaveReminder && this.data.isEditing) {
      wx.showModal({
        title: '提示',
        content: '您有未保存的修改，确定要离开吗？',
        success: (res) => {
          if (res.confirm) {
            // 用户确认离开，恢复原始数据并返回上一页
            this.restoreOriginalData()
            wx.navigateBack({ delta: 1 })
          }
        }
      })
      return true // 拦截默认返回行为
    }
    return false // 不拦截默认返回行为
  },

  /**
   * 计算年龄
   * @param {String} birthDate - 出生日期字符串
   * @returns {Number} - 计算得到的年龄
   */
  calculateAge(birthDate) {
    const birth = new Date(birthDate)
    const today = new Date()
    let age = today.getFullYear() - birth.getFullYear()
    const monthDiff = today.getMonth() - birth.getMonth()
    if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birth.getDate())) {
      age--
    }
    return age
  }
}) 